import express from 'express'
import cors from 'cors'
import bodyParser from 'body-parser'
import { Sequelize, DataTypes, Op } from 'sequelize'
import fs from 'fs'
import path from 'path'
import { fileURLToPath } from 'url'
import os from 'os'
import { EventEmitter } from 'events'

const __filename = fileURLToPath(import.meta.url)
const __dirname = path.dirname(__filename)

// 初始化Express应用
const app = express()
app.use(cors())
app.use(bodyParser.json({ limit: '1mb' }))

// 添加更详细的日志记录
const logRequest = (req, res, next) => {
  const start = Date.now()
  const { method, url, ip, body } = req
  
  console.log(`[${new Date().toISOString()}] ${method} ${url} - 开始处理 - IP: ${ip}`)
  console.log(`请求体:`, JSON.stringify(body, null, 2))
  
  // 捕获响应完成事件
  res.on('finish', () => {
    const duration = Date.now() - start
    const status = res.statusCode
    console.log(`[${new Date().toISOString()}] ${method} ${url} - ${status} - ${duration}ms - IP: ${ip}`)
  })
  
  next()
}

// 应用日志中间件
app.use(logRequest)

// 添加超时中间件
app.use((req, res, next) => {
  // 设置更长的超时，例如10秒
  req.setTimeout(10000, () => {
    res.status(408).json({ error: '请求超时' });
  });
  next();
});

// 添加简单的速率限制中间件
const requestCounts = new Map()
const RATE_LIMIT_WINDOW = 60 * 1000 // 1分钟
const RATE_LIMIT_MAX = 1000 // 每个IP每分钟最多100个请求

app.use((req, res, next) => {
  const ip = req.ip
  const now = Date.now()
  
  // 清理过期的请求计数
  if (!requestCounts.has(ip)) {
    requestCounts.set(ip, {
      count: 0,
      resetTime: now + RATE_LIMIT_WINDOW
    })
  } else {
    const record = requestCounts.get(ip)
    if (now > record.resetTime) {
      record.count = 0
      record.resetTime = now + RATE_LIMIT_WINDOW
    }
  }
  
  // 检查请求计数
  const record = requestCounts.get(ip)
  record.count++
  
  if (record.count > RATE_LIMIT_MAX) {
    return res.status(429).json({ 
      error: '请求过于频繁，请稍后再试',
      retryAfter: Math.ceil((record.resetTime - now) / 1000)
    })
  }
  
  next()
})

// 加载配置
let config = {
  databaseType: 'sqlite', // 当前使用的数据库类型
  databaseConfig: {
    sqlite: {
      type: 'sqlite',
      storage: path.join(__dirname, '../database.sqlite')
    },
    mysql: {
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      user: 'root',
      password: '',
      database: 'admin_app'
    },
    mssql: {
      type: 'mssql',
      host: 'localhost',
      port: 1433,
      user: 'sa',
      password: '',
      database: 'admin_app',
      options: {
        encrypt: true
      }
    }
  },
  
  // 获取当前数据库配置的辅助方法
  getCurrentDatabaseConfig() {
    return this.databaseConfig[this.databaseType];
  },
  
  // 更新数据库配置的方法
  updateDatabaseConfig(type, newConfig) {
    if (!this.databaseConfig[type]) {
      throw new Error(`不支持的数据库类型: ${type}`);
    }
    this.databaseConfig[type] = {
      ...this.databaseConfig[type],
      ...newConfig,
      type // 确保类型不被覆盖
    };
  }
};

// 确保配置文件存在
const configPath = path.join(__dirname, 'config.json');
try {
  if (fs.existsSync(configPath)) {
    const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
    config = {
      ...config,
      ...savedConfig,
      // 保持方法不被覆盖
      getCurrentDatabaseConfig: config.getCurrentDatabaseConfig,
      updateDatabaseConfig: config.updateDatabaseConfig
    };
  }
} catch (error) {
  console.error('加载配置文件失败:', error);
}

// 保存配置到文件的函数
function saveConfig() {
  try {
    // 创建一个不包含方法的配置副本
    const configToSave = {
      databaseType: config.databaseType,
      databaseConfig: config.databaseConfig
    };
    fs.writeFileSync(configPath, JSON.stringify(configToSave, null, 2));
  } catch (error) {
    console.error('保存配置文件失败:', error);
  }
}

// 获取数据库方言配置
function getDialectConfig(dbConfig) {
  const baseConfig = {
    logging: false,
    define: {
      // 禁用 Sequelize 的自动时间戳
      timestamps: false,
      // 禁用外键约束检查
      foreignKeys: false
    }
  };

  switch (dbConfig.type) {
    case 'mysql':
      return {
        ...baseConfig,
        dialect: 'mysql',
        host: dbConfig.host,
        port: dbConfig.port || 3306,
        username: dbConfig.user,
        password: dbConfig.password,
        database: dbConfig.database,
        dialectOptions: {
          charset: 'utf8mb4'
        }
      };
    case 'sqlite':
      return {
        ...baseConfig,
        dialect: 'sqlite',
        storage: dbConfig.storage
      };
    case 'mssql':
      return {
        ...baseConfig,
        dialect: 'mssql',
        host: dbConfig.host,
        port: dbConfig.port || 1433,
        username: dbConfig.user,
        password: dbConfig.password,
        database: dbConfig.database,
        dialectOptions: {
          options: {
            trustServerCertificate: true
          }
        }
      };
    default:
      throw new Error(`不支持的数据库类型: ${dbConfig.type}`);
  }
}

// 创建数据库连接
async function createSequelizeInstance(config) {
  const sequelize = new Sequelize(getDialectConfig(config));
  
  // 根据数据库类型执行特定的初始化
  if (config.type === 'sqlite') {
    // SQLite 特有的初始化
    await sequelize.query('PRAGMA foreign_keys = ON');
  }
  
  return sequelize;
}

// 处理日期时间格式
function formatDateTime(value) {
  if (!value) return 'NULL';
  try {
    // 移除多余的引号
    const dateStr = value.replace(/['"]/g, '');
    const date = new Date(dateStr);
    // 格式化为 MySQL 标准格式
    return `'${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}'`;
  } catch (error) {
    console.error('日期格式化错误:', error);
    return 'NULL';
  }
}

// 获取表中的现有记录
async function getExistingRecords(sequelize, tableName, config) {
  try {
    const [results] = await sequelize.query(
      config.type === 'mysql' 
        ? `SELECT * FROM \`${tableName}\``
        : `SELECT * FROM "${tableName}"`
    );
    return results;
  } catch (error) {
    console.error('获取现有记录时出错:', error);
    return [];
  }
}

// 检查表是否存在
async function tableExists(sequelize, tableName, config) {
  try {
    if (config.type === 'mysql') {
      const [results] = await sequelize.query(`
        SELECT TABLE_NAME 
        FROM information_schema.TABLES 
        WHERE TABLE_SCHEMA = '${config.database}' 
        AND TABLE_NAME = '${tableName}'
      `);
      return results.length > 0;
    } else if (config.type === 'sqlite') {
      const [results] = await sequelize.query(`
        SELECT name FROM sqlite_master 
        WHERE type='table' AND name = '${tableName}'
      `);
      return results.length > 0;
    }
    return false;
  } catch (error) {
    console.error('检查表是否存在时出错:', error);
    return false;
  }
}

// 修改数据迁移函数
async function migrateDatabaseData(oldConfig, newConfig) {
  console.log('开始数据迁移...');
  console.log('源配置:', oldConfig);
  console.log('目标配置:', newConfig);

  try {
    // 获取源数据库和目标数据库的配置
    const sourceDialect = getDialectConfig({
      type: oldConfig.type,
      ...oldConfig[oldConfig.type]
    });
    
    const targetDialect = getDialectConfig({
      type: newConfig.type,
      ...newConfig[newConfig.type]
    });

    console.log('源数据库配置:', sourceDialect);
    console.log('目标数据库配置:', targetDialect);

    // ... 后续迁移逻辑 ...

  } catch (error) {
    console.error('数据同步失败:', error);
    throw error;
  }
}

// 获取设置接口
app.get('/api/settings', (req, res) => {
  res.json({
    databaseType: config.databaseType,
    databaseConfig: config.databaseConfig
  });
});

// 添加重新加载配置的函数
async function reloadConfiguration() {
  try {
    console.log('正在重新加载配置...');
    
    // 重新加载配置文件
    if (fs.existsSync(configPath)) {
      const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
      config = {
        ...config,
        ...savedConfig,
        // 保持方法不被覆盖
        getCurrentDatabaseConfig: config.getCurrentDatabaseConfig,
        updateDatabaseConfig: config.updateDatabaseConfig
      };
    }
  } catch (error) {
    console.error('重新加载配置失败:', error);
    throw error;
  }
}

// 修改设置接口
app.post('/api/settings', async (req, res) => {
  try {
    console.log('POST /api/settings - 开始处理');
    console.log('请求体:', req.body);
    
    const { databaseType, databaseConfig } = req.body;
    
    // 验证参数
    if (!databaseType || !databaseConfig) {
      throw new Error('缺少必要的配置参数');
    }

    // 获取当前配置
    const oldConfig = {
      type: config.databaseType,
      sqlite: databaseConfig.sqlite,
      mysql: databaseConfig.mysql,
      sqlserver: databaseConfig.sqlserver
    };

    // 准备新配置对象，保持与请求体相同的结构
    const newConfig = {
      type: databaseType,
      sqlite: databaseConfig.sqlite,
      mysql: databaseConfig.mysql,
      sqlserver: databaseConfig.sqlserver
    };

    console.log('当前配置:', oldConfig);
    console.log('新配置:', newConfig);

    // 执行迁移
    await migrateDatabaseData(oldConfig, newConfig);
    
    // 更新配置
    config.databaseType = databaseType;
    config.databaseConfig = databaseConfig;
    
    // 保存配置
    saveConfig();
    
    // 重新加载配置
    await reloadConfiguration();
    
    res.json({
      success: true,
      config: {
        databaseType,
        databaseConfig
      },
      message: '设置已更新并完成配置重载'
    });
    
  } catch (error) {
    console.error('更新设置失败:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '更新设置失败: ' + error.message
    });
  }
});

// 初始化数据库连接
let sequelize
switch (config.databaseType) {
  case 'mysql':
    sequelize = new Sequelize(
      config.databaseConfig.mysql.database,
      config.databaseConfig.mysql.username,
      config.databaseConfig.mysql.password,
      {
        host: config.databaseConfig.mysql.host,
        port: config.databaseConfig.mysql.port,
        dialect: 'mysql',
        logging: console.log
      }
    )
    break
  case 'sqlserver':
    sequelize = new Sequelize(
      config.databaseConfig.sqlserver.database,
      config.databaseConfig.sqlserver.user,
      config.databaseConfig.sqlserver.password,
      {
        host: config.databaseConfig.sqlserver.server,
        port: config.databaseConfig.sqlserver.port,
        dialect: 'mssql',
        logging: console.log
      }
    )
    break
  case 'sqlite':
  default:
    sequelize = new Sequelize({
      dialect: 'sqlite',
      storage: config.databaseConfig.sqlite.storage,
      logging: console.log,
      retry: {
        max: 1, // 增加最大重试次数
        match: [
          /SQLITE_BUSY/,  // 数据库锁定时重试
          /SQLITE_LOCKED/ // 表被锁定时重试
        ],
        backoffBase: 30000, // 重试间隔基数(毫秒)
        backoffExponent: 1.5 // 重试间隔指数
      },
      pool: {
        max: 5,
        min: 0,
        acquire: 60000, // 增加获取连接超时时间
        idle: 10000
      },
      transactionType: 'IMMEDIATE' // 使用立即事务模式
    })
    break
}

// 确保在数据库初始化时设置 WAL 模式
//await sequelize.query('PRAGMA journal_mode=WAL;');
//await sequelize.query('PRAGMA busy_timeout = 6000;'); // 设置忙等待超时为6秒

// 定义模型表
const Model = sequelize.define('Model', {
  name: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      notEmpty: true
    }
  },
  displayName: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notEmpty: true
    }
  },
  description: {
    type: DataTypes.TEXT,
    allowNull: true
  },
  fields: {
    type: DataTypes.JSON,
    allowNull: false,
    defaultValue: []
  }
})

// 定义设置表
const Setting = sequelize.define('Setting', {
  key: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    primaryKey: true
  },
  value: {
    type: DataTypes.JSON,
    allowNull: true
  }
})

// 定义授权IP表
const AuthorizedIP = sequelize.define('AuthorizedIP', {
  ip: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isIP: true
    }
  },
  description: {
    type: DataTypes.STRING,
    allowNull: true
  },
  enabled: {
    type: DataTypes.BOOLEAN,
    defaultValue: true
  },
  lastAccess: {
    type: DataTypes.DATE,
    allowNull: true
  }
});

// 添加IP授权缓存
let authorizedIPCache = new Map();

// 重新加载IP授权缓存
async function reloadIPAuthorization() {
  try {
    console.log('正在重新加载IP授权配置...');
    
    // 清空现有缓存
    const oldSize = authorizedIPCache.size;
    authorizedIPCache.clear();
    
    // 从数据库加载所有启用的IP
    const authorizedIPs = await AuthorizedIP.findAll({
      where: {
        enabled: true
      }
    });
    
    // 更新缓存
    authorizedIPs.forEach(ip => {
      authorizedIPCache.set(ip.ip, {
        id: ip.id,
        description: ip.description,
        lastAccess: ip.lastAccess
      });
    });
    
    console.log(`IP授权配置已重新加载:`);
    console.log(`- 原缓存数量: ${oldSize}`);
    console.log(`- 新缓存数量: ${authorizedIPCache.size}`);
    console.log(`- 已启用的IP列表:`);
    authorizedIPs.forEach(ip => {
      console.log(`  * ${ip.ip} (${ip.description || '无描述'})`);
    });
    
    return true;
  } catch (error) {
    console.error('重新加载IP授权配置失败:', error);
    throw error;
  }
}

// IP授权检查中间件
const checkIPAuthorization = async (req, res, next) => {
  if (req.path.startsWith('/api/auth')) {
    return next();
  }

  // 修改获取真实IP的逻辑
  const realIP = req.socket.remoteAddress;
  
  console.log(`\n=== IP授权检查 ===`);
  console.log(`请求信息:`);
  console.log(`- 真实IP: ${realIP}`);
  console.log(`- 路径: ${req.path}`);
  console.log(`- 方法: ${req.method}`);
  console.log(`- Socket信息:`, {
    remoteAddress: req.socket.remoteAddress,
    remoteFamily: req.socket.remoteFamily
  });

  // 如果是本地IP，直接放行
  if (isLocalIP(realIP)) {
    console.log(`本地IP直接放行: ${realIP}`);
    console.log('=== 检查结束 ===\n');
    return next();
  }

  try {
    // 先查询IP是否在授权列表中（不管状态）
    let authorizedIP = await AuthorizedIP.findOne({
      where: { ip: realIP }
    });
   if(!authorizedIP){
     await AuthorizedIP.create({
      ip: realIP,
      enabled: true,
      lastAccess: new Date()
     })
    authorizedIP=await AuthorizedIP.findOne({
      where: { ip: realIP }
    });
     }

    // 如果IP未配置或状态为false，拒绝访问
    if (!authorizedIP || !authorizedIP.enabled) {
      const reason = !authorizedIP ? '未配置授权' : '授权已禁用';
      console.log(`拒绝访问:`);
      console.log(`- IP: ${realIP}`);
      console.log(`- 原因: ${reason}`);
      console.log('=== 检查结束 ===\n');
      
      return res.status(403).json({
        error: `IP访问被拒绝 - ${reason}`,
        code: 'UNAUTHORIZED_IP',
        ip: realIP,
        status: !authorizedIP ? 'unconfigured' : 'disabled'
      });
    }

    // IP已授权且状态为enabled，更新访问时间
    await authorizedIP.update({ lastAccess: new Date() });
    
    console.log(`授权IP访问成功:`);
    console.log(`- IP: ${realIP}`);
    console.log('=== 检查结束 ===\n');
    
    next();
  } catch (error) {
    console.error('IP授权检查失败:', error);
    res.status(500).json({
      error: 'IP授权检查失败',
      code: 'CHECK_ERROR'
    });
  }
};

// 修改日志中间件
app.use((req, res, next) => {
  const start = Date.now();
  const realIP = req.socket.remoteAddress;

  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url} - ${res.statusCode} - ${duration}ms - IP: ${realIP}`);
  });

  next();
});

// 获取本地IP地址的函数
function getLocalIPs() {
  const networkInterfaces = os.networkInterfaces();
  const ips = new Set(['::1', '127.0.0.1', 'localhost']);
  
  Object.values(networkInterfaces).forEach(interfaces => {
    interfaces.forEach(iface => {
      if (!iface.internal) {
        ips.add(iface.address);
      }
    });
  });
  
  return ips;
}

// 初始化IP授权状态
async function initializeAuthStatus() {
  try {
    // 确保表已创建
    await AuthorizedIP.sync();
    
    // 获取所有已授权的IP
    const authorizedIPs = await AuthorizedIP.findAll({
      where: {
        enabled: true
      }
    });
    
    // 更新缓存
    authorizedIPCache.clear();
    authorizedIPs.forEach(ip => {
      authorizedIPCache.set(ip.ip, {
        id: ip.id,
        description: ip.description,
        lastAccess: ip.lastAccess
      });
    });
    
    console.log(`已加载 ${authorizedIPCache.size} 个授权IP`);
    return true;
  } catch (error) {
    console.error('初始化IP授权状态失败:', error);
    throw error;
  }
}

// 应用中间件 - 注意顺序很重要
app.use(cors());
app.use(bodyParser.json({ limit: '1mb' }));
app.use(logRequest);

// 在其他路由之前应用IP授权检查中间件
app.use('/api', checkIPAuthorization);

// 添加一个简单的事件发布/订阅系统
const authEvents = new EventEmitter();

// 全局授权状态
let authorizedIPsStatus = new Map();

// 监听授权状态变更事件
authEvents.on('auth-status-changed', async () => {
  await initializeAuthStatus();
});

// 添加本地IP检查函数
function isLocalIP(ip) {
  const localIPs = new Set([
    '127.0.0.1',
    '::1',
    'localhost',
    '::ffff:127.0.0.1'
    ,'0.0.0.0'
  ]);
  return localIPs.has(ip);
}

// 添加一个简单的测试端点
app.get('/api/test-auth', (req, res) => {
  res.json({
    message: '如果你看到这个消息，说明你的IP已经通过授权检查',
    timestamp: new Date().toISOString()
  });
});

// IP授权管理API
// 获取所有授权IP
app.get('/api/auth/ips', async (req, res) => {
  try {
    console.log('获取授权IP列表');
    const ips = await AuthorizedIP.findAll({
      order: [['lastAccess', 'DESC']]
    });
    
    console.log('查询结果:', ips.length ? ips : '无授权IP');
    res.json(ips);
  } catch (error) {
    console.error('获取授权IP列表失败:', error);
    res.status(500).json({
      error: '获取授权IP列表失败',
      message: error.message
    });
  }
});

// 添加授权IP
app.post('/api/auth/ips', async (req, res) => {
  const transaction = await sequelize.transaction();
  try {
    const { ip, description } = req.body;
    console.log('添加授权IP请求:', { ip, description });
    
    if (!ip) {
      return res.status(400).json({
        error: 'IP地址不能为空'
      });
    }

    // 检查IP是否已存在
    const existingIP = await AuthorizedIP.findOne({
      where: { ip },
      transaction
    });

    if (existingIP) {
      await transaction.rollback();
      return res.status(409).json({
        error: 'IP地址已存在'
      });
    }

    const authorizedIP = await AuthorizedIP.create({
      ip,
      description,
      enabled: true,
      lastAccess: null
    }, { transaction });

    await transaction.commit();
    
    console.log(`新增IP授权成功 - IP: ${ip}, 描述: ${description}`);
    
    res.status(201).json({
      success: true,
      data: authorizedIP,
      message: `IP ${ip} 已添加到授权列表`
    });
  } catch (error) {
    await transaction.rollback();
    console.error('添加授权IP失败:', error);
    res.status(500).json({
      error: '添加授权IP失败',
      message: error.message
    });
  }
});

// 更新授权IP
app.put('/api/auth/ips/:id', async (req, res) => {
  const transaction = await sequelize.transaction();
  try {
    const { id } = req.params;
    const { enabled, description } = req.body;

    console.log(`更新IP授权请求 - ID: ${id}`, { enabled, description });

    const authorizedIP = await AuthorizedIP.findByPk(id, { transaction });
    if (!authorizedIP) {
      await transaction.rollback();
      return res.status(404).json({
        error: '授权IP不存在'
      });
    }

    await authorizedIP.update({
      enabled: enabled !== undefined ? enabled : authorizedIP.enabled,
      description: description || authorizedIP.description
    }, { transaction });

    await transaction.commit();

    console.log(`IP授权更新成功 - IP: ${authorizedIP.ip}, 启用状态: ${enabled}`);
    
    res.json({
      success: true,
      data: authorizedIP,
      message: `IP ${authorizedIP.ip} 已${enabled ? '启用' : '禁用'}授权`
    });
  } catch (error) {
    await transaction.rollback();
    console.error('更新授权IP失败:', error);
    res.status(500).json({
      error: '更新授权IP失败',
      message: error.message
    });
  }
});

// 删除授权IP
app.delete('/api/auth/ips/:id', async (req, res) => {
  const transaction = await sequelize.transaction();
  try {
    const { id } = req.params;
    console.log(`删除IP授权请求 - ID: ${id}`);
    
    const authorizedIP = await AuthorizedIP.findByPk(id, { transaction });
    if (!authorizedIP) {
      await transaction.rollback();
      return res.status(404).json({
        error: '授权IP不存在'
      });
    }

    const ipAddress = authorizedIP.ip;
    await authorizedIP.destroy({ transaction });
    await transaction.commit();
    
    console.log(`删除IP授权成功 - IP: ${ipAddress}`);
    
    res.json({
      success: true,
      message: `IP ${ipAddress} 已从授权列表中删除`
    });
  } catch (error) {
    await transaction.rollback();
    console.error('删除授权IP失败:', error);
    res.status(500).json({
      error: '删除授权IP失败',
      message: error.message
    });
  }
});

// 存储动态模型
const dynamicModels = {}

// 初始化数据库
async function initDatabase() {
  try {
    console.log('正在初始化数据库...')
    await sequelize.authenticate()
    console.log('数据库连接成功')
    
    // 同步模型表
    await Model.sync()
    console.log('模型表同步完成')
    
    // 同步设置表
    await Setting.sync()
    console.log('设置表同步完成')
    
    // 同步授权IP表
    await AuthorizedIP.sync()
    console.log('授权IP表同步完成')
    
    // 初始化设置
    const databaseSettings = await Setting.findOne({ where: { key: 'database' } })
    if (!databaseSettings) {
      await Setting.create({
        key: 'database',
        value: {
          type: config.databaseType,
          config: config.databaseConfig
        }
      })
      console.log('数据库设置初始化完成')
    }
  } catch (error) {
    console.error('数据库初始化失败:', error)
    throw error
  }
}

// 根据字段类型获取Sequelize数据类型
function getSequelizeType(fieldType) {
  switch (fieldType) {
    case 'string':
      return DataTypes.STRING
    case 'text':
      return DataTypes.TEXT
    case 'integer':
      return DataTypes.INTEGER
    case 'float':
      return DataTypes.FLOAT
    case 'boolean':
      return DataTypes.BOOLEAN
    case 'date':
      return DataTypes.DATEONLY
    case 'datetime':
      return DataTypes.DATE
    case 'json':
      return DataTypes.JSON
    default:
      return DataTypes.STRING
  }
}

// 创建动态模型
function createDynamicModel(modelDef) {
  console.log(`创建动态模型: ${modelDef.name}`)
  
  // 定义字段
  const fields = {}
  
  // 添加ID字段
  fields.id = {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true
  }
  
  // 添加自定义字段
  for (const field of modelDef.fields) {
    fields[field.name] = {
      type: getSequelizeType(field.type),
      allowNull: !field.required,
      defaultValue: field.defaultValue !== undefined ? field.defaultValue : null
    }
  }
  
  // 添加创建时间和更新时间
  fields.createdAt = {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW
  }
  
  fields.updatedAt = {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW
  }
  
  // 定义模型
  const dynamicModel = sequelize.define(modelDef.name, fields, {
    tableName: `data_${modelDef.name}`,
    timestamps: true
  })
  
  // 存储模型
  dynamicModels[modelDef.name] = dynamicModel
  
  return dynamicModel
}

// 创建并同步动态模型
async function createAndSyncDynamicModel(modelDef) {
  try {
    console.log(`创建动态模型: ${modelDef.name}`)
    
    // 确保modelDef.fields是数组
    let fields = []
    console.log(1)
    try {
      if (Array.isArray(modelDef.fields)) {
        fields = modelDef.fields
      } else if (typeof modelDef.fields === 'string') {
        fields = JSON.parse(modelDef.fields)
      }
    } catch (err) {
      console.error(`解析${modelDef.name}模型字段失败:`, err)
      throw new Error('字段解析失败')
    }
    console.log(2)
    // 检查模型是否已存在
    if (dynamicModels[modelDef.name]) {
      console.log(`模型 ${modelDef.name} 已存在，跳过创建`)
      return dynamicModels[modelDef.name]
    }
    console.log(3)
    // 创建模型定义
    const modelAttributes = {}
    
    // 添加ID字段
    modelAttributes.id = {
      type: DataTypes.STRING,
      primaryKey: true,
      
    }
    
    // 添加其他字段
    for (const field of fields) {
      let fieldType
      switch (field.type) {
        case 'string':
        case 'text':
          fieldType = DataTypes.STRING
          break
        case 'integer':
          fieldType = DataTypes.INTEGER
          break
        case 'number':
        case 'float':
          fieldType = DataTypes.FLOAT
          break
        case 'boolean':
          fieldType = DataTypes.BOOLEAN
          break
        case 'date':
          fieldType = DataTypes.DATEONLY
          break
          case 'json':
            fieldType = DataTypes.JSON
            break
        case 'datetime':
          fieldType = DataTypes.DATE
          break
        default:
          throw new Error(`不支持的字段类型: ${field.type}`)
      }
      console.log(4)
      modelAttributes[field.name] = {
        type: fieldType,
        allowNull: !field.required
      }
    }
    console.log(5)
    // 添加时间戳字段
    modelAttributes.createdAt = {
      type: DataTypes.DATE,
      defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
    }
    
    modelAttributes.updatedAt = {
      type: DataTypes.DATE,
      defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
    }
    console.log(6)
    // 创建模型
    const model = sequelize.define(modelDef.name, modelAttributes, {
      tableName: modelDef.name,
      timestamps: true,
      // 设置更长的查询超时时间
      dialectOptions: {
        timeout: 30000 // 30秒超时
      }
    })
    console.log(7)
    try {
      // 使用锁机制来确保原子性
      //await sequelize.transaction({ isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE }, async (t) => {
        console.log(`开始同步模型: ${modelDef.name}`)
        await model.sync({ alter: true}) // 使用alter选项
        console.log(`模型同步完成: ${modelDef.name}`)
      //})
      console.log(8)
      // 存储模型定义
      dynamicModels[modelDef.name] = model
      console.log(`动态模型创建成功: ${modelDef.name}`)
      console.log(9)
      return model  
    } catch (syncError) {
      console.log(-8)
      console.error(`同步模型失败: ${modelDef.name}`, syncError)
      throw syncError
    }
  } catch (err) {
    console.log(-8)
    console.error(`创建动态模型失败: ${modelDef.name}`, err)
    throw err
  }
}

// 加载所有模型
async function loadModels() {
  try {
    console.log('正在加载模型...')
    const models = await Model.findAll()
    console.log(`找到 ${models.length} 个模型`)
    
    for (const model of models) {
      try {
        await createAndSyncDynamicModel(model)
      } catch (error) {
        console.error(`加载模型 ${model.name} 失败:`, error)
      }
    }
    
    console.log('所有模型加载完成')
  } catch (error) {
    console.error('加载模型失败:', error)
    throw error
  }
}

// 统一错误处理中间件
function errorHandler(err, req, res, next) {
  console.error('API错误:', err)
  
  // 设置状态码
  const statusCode = err.statusCode || 500
  
  // 构建错误响应
  const errorResponse = {
    error: err.message || '服务器内部错误',
    status: statusCode
  }
  
  // 在开发环境中添加堆栈跟踪
  if (process.env.NODE_ENV !== 'production') {
    errorResponse.stack = err.stack
  }
  
  res.status(statusCode).json(errorResponse)
}

// API前缀
const API_PREFIX = '/api'

// 获取单个模型
app.get(`${API_PREFIX}/models/:name`, async (req, res, next) => {
  try {
    const { name } = req.params
    
    // 从数据库中查找模型
    const model = await Model.findOne({where:{name}})
    
    if (!model) {
      const error = new Error('模型不存在')
      error.statusCode = 404
      throw error
    }
    
    // 返回模型数据
    res.json(model)
  } catch (error) {
    // 设置适当的状态码
    error.statusCode = error.statusCode || 500
    next(error)
  }
})

// 获取所有模型
app.get(`${API_PREFIX}/models`, async (req, res, next) => {
  try {
    const models = await Model.findAll()
    res.json(models)
  } catch (error) {
    error.statusCode = error.statusCode || 500
    next(error)
  }
})

app.get(`${API_PREFIX}/models/:name`, async (req, res, next) => {
  try {
    const { name } = req.params
    console.log(`获取模型: ${name}`)
    
    const model = await Model.findOne({ where: { name } })
    if (!model) {
      const error = new Error('模型不存在')
      error.statusCode = 404
      throw error
    }
    
    res.json(model)
  } catch (error) {
    next(error)
  }
})

app.post(`${API_PREFIX}/models`, async (req, res, next) => {
  try {
    console.log('创建模型请求:', req.body)
    
    // 验证请求数据
    const { name, displayName, fields } = req.body
    
    if (!name) {
      const error = new Error('模型名称不能为空')
      error.statusCode = 400
      throw error
    }
    
    if (!displayName) {
      const error = new Error('显示名称不能为空')
      error.statusCode = 400
      throw error
    }
    
    if (!Array.isArray(fields) || fields.length === 0) {
      const error = new Error('字段定义不能为空')
      error.statusCode = 400
      throw error
    }
    
    // 验证字段名称
    const fieldNames = new Set()
    for (const field of fields) {
      if (!field.name) {
        const error = new Error('字段名称不能为空')
        error.statusCode = 400
        throw error
      }
      
      if (fieldNames.has(field.name)) {
        const error = new Error(`字段名称 "${field.name}" 重复`)
        error.statusCode = 400
        throw error
      }
      
      fieldNames.add(field.name)
    }
    
    // 检查模型名称是否已存在
    const existingModel = await Model.findOne({ where: { name } })
    if (existingModel) {
      const error = new Error('模型名称已存在')
      error.statusCode = 400
      throw error
    }
    
    try {
      // 创建模型记录
      console.log('创建模型记录...')
      const model = await Model.create(req.body)
      console.log('模型记录创建成功:', model.id)
      
      try {
        // 创建并同步动态模型
        console.log('创建并同步动态模型...')
        await createAndSyncDynamicModel(model)
        console.log('动态模型创建并同步成功')
        
        res.status(201).json(model)
      } catch (syncError) {
        // 如果同步失败，删除已创建的模型记录
        console.error('动态模型创建失败，正在回滚...', syncError)
        await Model.destroy({ where: { id: model.id } })
        throw syncError
      }
    } catch (error) {
      console.error('创建模型失败:', error)
      // 如果是数据库锁定错误，返回特定的错误信息
      if (error.message.includes('SQLITE_BUSY')) {
        const customError = new Error('数据库正忙，请稍后重试')
        customError.statusCode = 503
        throw customError
      }
      throw error
    }
  } catch (error) {
    // 设置适当的状态码
    error.statusCode = error.statusCode || 500
    next(error)
  }
})

// 更新模型接口
app.put('/api/models/:name', async (req, res) => {
  try {
    console.log('PUT /api/models/:name - 开始处理 - IP:', req.ip);
    console.log('请求体:', req.body);
    
    const modelName = req.params.name;
    console.log('更新模型:', modelName);
    
    // 使用 name 字段而不是 id 来查找模型
    const model = await Model.findOne({
      where: {
        name: modelName
      }
    });

    if (!model) {
      // 如果模型不存在，创建新模型
      const newModel = await Model.create({
        name: req.body.name,
        displayName: req.body.displayName,
        description: req.body.description,
        fields: req.body.fields
      });
      
      res.json({
        success: true,
        model: newModel,
        message: '模型创建成功'
      });
    } else {
      // 如果模型存在，更新它
      await model.update({
        displayName: req.body.displayName,
        description: req.body.description,
        fields: req.body.fields
      });
      
      res.json({
        success: true,
        model: model,
        message: '模型更新成功'
      });
    }
  } catch (error) {
    console.error('更新模型失败:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '更新模型失败'
    });
  }
});

app.delete(`${API_PREFIX}/models/:id`, async (req, res, next) => {
  try {
    const { id } = req.params
    
    // 查找模型
    const model = await Model.findByPk(id)
    if (!model) {
      return res.status(404).json({
        error: '模型不存在',
        code: 'MODEL_NOT_FOUND'
      })
    }

    // 获取动态模型
    const dynamicModel = dynamicModels[model.name]
    if (!dynamicModel) {
      return res.status(404).json({
        error: '动态模型不存在',
        code: 'DYNAMIC_MODEL_NOT_FOUND'
      })
    }

    // 检查表中是否存在数据
    const count = await dynamicModel.count()
    if (count > 0) {
      return res.status(400).json({
        error: `模型 "${model.displayName || model.name}" 中存在 ${count} 条数据`,
        code: 'MODEL_HAS_DATA',
        count: count,
        message: '请先清空表中数据后再删除模型'
      })
    }

    // 如果没有数据，执行删除操作
    try {
      // 删除表
      await dynamicModel.drop()
      console.log(`表 ${model.name} 删除成功`)
      
      // 删除模型记录
      await model.destroy()
      console.log(`模型记录 ${model.name} 删除成功`)
      
      // 从动态模型缓存中移除
      delete dynamicModels[model.name]
      
      return res.json({
        message: '模型删除成功',
        code: 'MODEL_DELETED'
      })
    } catch (err) {
      console.error(`删除模型失败:`, err)
      return res.status(500).json({
        error: '删除模型失败',
        code: 'DELETE_FAILED',
        message: '服务器内部错误'
      })
    }
  } catch (error) {
    console.error('删除模型时发生错误:', error)
    return res.status(500).json({
      error: '服务器内部错误',
      code: 'INTERNAL_ERROR'
    })
  }
})

// 获取单个模型信息
app.get(`${API_PREFIX}/models/:name`, async (req, res, next) => {
  try {
    const { name } = req.params
    
    // 从数据库中查找模型定义
    const model = await Model.findOne({ 
      where: { name },
    })
    
    if (!model) {
      const error = new Error('模型不存在')
      error.statusCode = 404
      throw error
    }
    
    // 获取动态模型的表结构信息
    const dynamicModel = dynamicModels[name]
    if (!dynamicModel) {
      const error = new Error('动态模型不存在')
      error.statusCode = 404
      throw error
    }
    
    // 返回模型信息
    res.json({
      ...model.toJSON(),
      attributes: dynamicModel.rawAttributes
    })
    
  } catch (error) {
    console.error('获取模型信息失败:', error)
    next(error)
  }
})

// 获取数据列表
app.get(`${API_PREFIX}/data/:model`, async (req, res) => {
  try {
    const { model } = req.params
    let pages=1
    let pageSize=10
    let wheres={}
    if(req.query.where)
    {
      wheres=req.query.where
    }
    if(req.query.page)
    {pages=req.query.page}
    if(req.query.pageSize)
    {
      pageSize=req.query.pageSize
    }
        console.log(pages,pageSize)
    const { page = pages, limit = pageSize, sort, order, ...filters } = req.query
    
    console.log(`获取 ${model} 数据，页码: ${page}, 每页: ${limit}, 排序: ${sort} ${order}`)
    console.log('过滤条件:', filters)
    
    // 检查模型是否存在
    if (!dynamicModels[model]) {
      try {
        // 尝试加载模型
        const [models] = await sequelize.query(`
          SELECT id, name, description, fields, createdAt, updatedAt,
          COALESCE(displayName, name) as displayName, 
          COALESCE(label, displayName, name) as label 
          FROM Models WHERE name = ?;
        `, {
          replacements: [model]
        })
        
        if (!models || models.length === 0) {
          return res.status(404).json({ error: `模型 "${model}" 不存在` })
        }
        
        const modelDef = models[0]
        
        // 解析 fields 字段
        if (typeof modelDef.fields === 'string') {
          modelDef.fields = JSON.parse(modelDef.fields)
        }
        
        await createAndSyncDynamicModel(modelDef)
      } catch (err) {
        console.error(`加载模型 "${model}" 失败:`, err)
        return res.status(500).json({ error: `加载模型失败: ${err.message}` })
      }
      
      if (!dynamicModels[model]) {
        return res.status(404).json({ error: `模型 "${model}" 不存在` })
      }
    }
    
    const dynamicModel = dynamicModels[model]
    
    // 构建查询条件
    const where = {}
    
    // 处理过滤条件
    for (const key in filters) {
      if (key.startsWith('filter_')) {
        const fieldName = key.replace('filter_', '')
        where[fieldName] = filters[key]
      }
    }
    if(wheres)
    {
      if (wheres) {
        Object.assign(where, wheres); // 正确地合并条件
      }
    }
    //console.log(where)
    // 构建排序
    const orderOptions = []
    if (sort) {
      orderOptions.push([sort, order === 'desc' ? 'DESC' : 'ASC'])
    } else {
      // 默认按 id 降序排序
      orderOptions.push(['id', 'DESC'])
    }
    
    // 解析分页参数，确保是数字
    const pageNum = parseInt(page, 10) || 1
    const limitNum = parseInt(limit, 10) || 10
    
    console.log(`查询参数: 页码=${pageNum}, 每页=${limitNum}, 排序=${JSON.stringify(orderOptions)}, 条件=${JSON.stringify(where)}`)
    
    // 查询数据
    const offset = (pageNum - 1) * limitNum
    
    // 使用 findAndCountAll 获取总数和分页数据
    const result = await dynamicModel.findAndCountAll({
      where,
      order: orderOptions,
      limit: limitNum,
      offset: offset
    })
    
    console.log(`查询结果: 总数=${result.count}, 当前页记录数=${result.rows.length}`)
    
    return res.json({
      records: result.rows,
      total: result.count,
      page: pageNum,
      limit: limitNum
    })
  } catch (error) {
    console.error('获取数据失败:', error)
    return res.status(500).json({ error: `获取数据失败: ${error.message}` })
  }
})

// 获取单条数据
app.get(`${API_PREFIX}/data/:modelName/:id`, async (req, res, next) => {
  try {
    const { modelName, id } = req.params
    
    // 设置响应超时时间
    req.setTimeout(30000) // 30秒超时
    res.setTimeout(30000)
    
    // 获取模型定义
    const model = await Model.findOne({ 
      where: { name: modelName },
      // 添加超时选项
      timeout: 5000 
    })
    
    if (!model) {
      return res.status(404).json({
        error: '模型不存在',
        code: 'MODEL_NOT_FOUND'
      })
    }
    
    // 获取动态模型
    const dynamicModel = dynamicModels[modelName]
    if (!dynamicModel) {
      return res.status(404).json({
        error: '动态模型不存在',
        code: 'DYNAMIC_MODEL_NOT_FOUND'
      })
    }
    
    // 查询数据，添加错误处理和超时
    try {
      const data = await dynamicModel.findByPk(id, {
        timeout: 5000,
        // 添加事务隔离级别
        isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED
      })
      
      if (!data) {
        return res.status(404).json({
          error: '数据不存在',
          code: 'DATA_NOT_FOUND'
        })
      }
      
      // 确保响应被正确发送
      res.json(data)
    } catch (queryError) {
      console.error('查询数据失败:', queryError)
      return res.status(500).json({
        error: '查询数据失败',
        message: queryError.message,
        code: 'QUERY_FAILED'
      })
    }
  } catch (error) {
    console.error('获取数据失败:', error)
    // 确保错误响应被发送
    if (!res.headersSent) {
      return res.status(500).json({
        error: '服务器内部错误',
        message: error.message,
        code: 'INTERNAL_ERROR'
      })
    }
  }
})

// 简化单条记录查询
app.get(`${API_PREFIX}/data/:model/:id`, async (req, res, next) => {
  try {
    const { model: modelName, id } = req.params
    
    // 简单的SQL查询
    const sql = `SELECT * FROM ${modelName} WHERE id = ${id} LIMIT 1`
    
    // 直接执行SQL查询
    const [rows] = await sequelize.query(sql, { 
      type: sequelize.QueryTypes.SELECT,
      raw: true,
      logging: false
    })
    
    if (!rows || rows.length === 0) {
      return res.status(404).json({ error: '记录不存在' })
    }
    
    // 直接返回第一条记录
    res.json(rows[0])
  } catch (error) {
    console.error('记录查询失败:', error.message)
    res.status(500).json({ error: '记录查询失败' })
  }
})

// 添加全局错误处理中间件
app.use((err, req, res, next) => {
  console.error('全局错误处理:', err);
  
  // 设置状态码
  const statusCode = err.statusCode || 500;
  
  // 构建错误响应
  const errorResponse = {
    error: err.message || '服务器内部错误',
    status: statusCode,
    path: req.path,
    timestamp: new Date().toISOString()
  };
  
  // 在开发环境中添加堆栈信息
  if (process.env.NODE_ENV !== 'production') {
    errorResponse.stack = err.stack;
  }
  
  // 发送错误响应
  res.status(statusCode).json(errorResponse);
});

// 添加 GUID 生成函数
function generateGUID() {
  return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}

// 修改创建记录的路由
app.post(`${API_PREFIX}/data/:model`, async (req, res) => {
  const maxRetries = 5;
  let retryCount = 0;
  
  async function attemptCreate() {
    try {
      const { model: modelName } = req.params;
      
      // 检查请求体是否为空
      if (!req.body || Object.keys(req.body).length === 0) {
        return res.status(400).json({ error: '请求数据不能为空' });
      }
      
      // 生成32位GUID
      const guid = generateGUID();
      console.log(`生成新的GUID: ${guid}`);
      
      // 使用事务来确保数据一致性
      const result = await sequelize.transaction(async (t) => {
        // 检查动态模型是否存在
        const modelDef = await Model.findOne({ 
          where: { name: modelName },
          transaction: t
        });
        
        if (!modelDef) {
          throw new Error(`模型 "${modelName}" 不存在`);
        }
        
        // 确保modelDef.fields是数组
        let fields = []
        try {
          if (Array.isArray(modelDef.fields)) {
            fields = modelDef.fields
          } else if (typeof modelDef.fields === 'string') {
            fields = JSON.parse(modelDef.fields)
          }
          
          console.log(`解析后的字段:`, fields)
        } catch (err) {
          console.error(`解析${modelName}模型字段失败:`, err)
          fields = []
        }
        
        // 验证必填字段
        const requiredFields = fields.filter(f => f.required).map(f => f.name)
        console.log(`必填字段:`, requiredFields)
        
        for (const field of requiredFields) {
          if (req.body[field] === undefined || req.body[field] === null || req.body[field] === '') {
            throw new Error(`字段 "${field}" 不能为空`)
          }
        }
        
        // 检查动态模型是否存在
        if (!dynamicModels[modelName]) {
          console.log(`动态模型不存在，尝试创建:`, modelName)
          
          // 尝试重新加载模型
          try {
            await createAndSyncDynamicModel(modelDef)
          } catch (err) {
            console.error(`创建动态模型失败:`, err)
            throw err
          }
          
          if (!dynamicModels[modelName]) {
            throw new Error(`无法创建模型 "${modelName}" 的数据表`)
          }
        }
        
        // 创建记录
        const model = dynamicModels[modelName]
        console.log(`使用模型创建记录:`, modelName)
        
        // 处理数据，确保类型正确
        const processedData = {
          id: guid,  // 自动添加生成的GUID
        }

        // 处理请求中的字段
        for (const key in req.body) {
          // 查找字段定义
          const fieldDef = fields.find(f => f.name === key)
          if (fieldDef) {
            // 根据字段类型处理值
            switch (fieldDef.type) {
              case 'integer':
                processedData[key] = parseInt(req.body[key]) || 0
                break
              case 'number':
              case 'float':
                processedData[key] = parseFloat(req.body[key]) || 0
                break
              case 'boolean':
                processedData[key] = req.body[key] === 'true' || req.body[key] === true
                break
              default:
                processedData[key] = req.body[key]
            }
          } else {
            // 没有字段定义，保持原值
            processedData[key] = req.body[key]
          }
        }
        processedData["id"]=guid;
        console.log(`处理后的数据:`, processedData);
        
        const record = await model.create(processedData, {
          transaction: t,
          lock: t.LOCK.UPDATE
        });
        
        console.log(`记录创建成功:`, record.toJSON());
        return record;
      }, {
        isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
      });
      
      console.log(`记录创建成功，ID: ${result.id}`);
      return res.status(201).json(result);
      
    } catch (error) {
      // 检查是否是数据库锁定错误
      if ((error.message.includes('SQLITE_BUSY') || 
           error.message.includes('SQLITE_LOCKED')) && 
          retryCount < maxRetries) {
        
        retryCount++;
        const delay = Math.min(100 * Math.pow(2, retryCount), 2000); // 指数退避策略
        
        console.log(`数据库忙，第 ${retryCount} 次重试，等待 ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        
        return attemptCreate(); // 递归重试
      }
      
      // 如果不是锁定错误或已超过重试次数，则返回错误
      console.error('创建记录失败:', error);
      
      if (error.name === 'SequelizeValidationError') {
        return res.status(400).json({ 
          error: `数据验证失败: ${error.errors.map(e => e.message).join(', ')}` 
        });
      } else if (error.name === 'SequelizeUniqueConstraintError') {
        return res.status(409).json({ 
          error: `数据已存在: ${error.errors.map(e => e.message).join(', ')}` 
        });
      } else {
        return res.status(500).json({ 
          error: `创建记录失败: ${error.message}`,
          retryCount
        });
      }
    }
  }
  
  return attemptCreate();
});

// 更新数据
app.put(`${API_PREFIX}/data/:modelName/:id`, async (req, res, next) => {
  try {
    const { modelName, id } = req.params
    const updateData = req.body
    
    console.log('更新请求参数:', {
      modelName,
      id,
      updateData
    })
    
    // 获取模型定义 - 修复 findByPk 的使用
    const model = await Model.findOne({ 
      where: { name: modelName }
    })
    
    if (!model) {
      console.log(`模型 ${modelName} 不存在`)
      return res.status(404).json({
        error: '模型不存在',
        code: 'MODEL_NOT_FOUND'
      })
    }
    
    // 获取动态模型
    const dynamicModel = dynamicModels[modelName]
    if (!dynamicModel) {
      console.log(`动态模型 ${modelName} 不存在`)
      return res.status(404).json({
        error: '动态模型不存在',
        code: 'DYNAMIC_MODEL_NOT_FOUND'
      })
    }
    
    // 查找要更新的数据 - 直接传入 id 值
    const data = await dynamicModel.findByPk(id)
    if (!data) {
      console.log(`数据记录 ${id} 不存在`)
      return res.status(404).json({
        error: '数据不存在',
        code: 'DATA_NOT_FOUND'
      })
    }

    // 更新数据 - 使用 update 方法而不是 save
    await data.update(updateData)
    
    // 返回更新后的数据
    const updatedData = await dynamicModel.findByPk(id)
    console.log('更新成功:', updatedData.toJSON())
    res.json(updatedData)
  } catch (error) {
    console.error('更新数据失败:', error)
    next(error)
  }
})

app.delete(`${API_PREFIX}/data/:model/:id`, async (req, res, next) => {
  try {
    const { model: modelName, id } = req.params
    console.log(`删除${modelName}记录: ${id}`)
    
    // 检查动态模型是否存在
    if (!dynamicModels[modelName]) {
      // 尝试重新加载模型
      const modelDef = await Model.findOne({ where: { name: modelName } })
      if (modelDef) {
        await createAndSyncDynamicModel(modelDef)
      } else {
        const error = new Error('模型不存在')
        error.statusCode = 404
        throw error
      }
    }
    
    const model = dynamicModels[modelName]
    const record = await model.findByPk(id)
    
    if (!record) {
      const error = new Error('记录不存在')
      error.statusCode = 404
      throw error
    }
    
    await record.destroy()
    res.status(204).send()
  } catch (error) {
    next(error)
  }
})

// 系统设置API
// app.get('${API_PREFIX}/settings', (req, res) => {
//   res.json(config);
// });

// app.post('${API_PREFIX}/settings', (req, res) => {
//   config = req.body;
//   res.json(config);
// });

app.post('/api/settings/test-connection', async (req, res) => {
  try {
    const { databaseType, databaseConfig } = req.body
    let testSequelize
    
    switch (databaseType) {
      case 'mysql':
        testSequelize = new Sequelize(
          databaseConfig.mysql.database,
          databaseConfig.mysql.username,
          databaseConfig.mysql.password,
          {
            host: databaseConfig.mysql.host,
            port: databaseConfig.mysql.port,
            dialect: 'mysql'
          }
        )
        break
      case 'sqlserver':
        testSequelize = new Sequelize(
          databaseConfig.sqlserver.database,
          databaseConfig.sqlserver.user,
          databaseConfig.sqlserver.password,
          {
            host: databaseConfig.sqlserver.server,
            port: databaseConfig.sqlserver.port,
            dialect: 'mssql'
          }
        )
        break
      case 'sqlite':
      default:
        testSequelize = new Sequelize({
          dialect: 'sqlite',
          storage: databaseConfig.sqlite.storage
        })
        break
    }
    
    await testSequelize.authenticate()
    res.json({ success: true, message: '连接成功' })
  } catch (error) {
    res.status(500).json({ success: false, message: `连接失败: ${error.message}` })
  }
})

// 添加服务器状态API
app.get('/api/status', (req, res) => {
  res.json({
    status: 'running',
    time: new Date().toISOString(),
    uptime: process.uptime(),
    memory: process.memoryUsage()
  });
});

// 添加一个简单的测试路由
app.get(`${API_PREFIX}/ping`, (req, res) => {
  res.json({ message: 'pong', time: new Date().toISOString() })
})

// 获取本机所有可访问的IP地址和URL
function getServerUrls(port) {
  const networkInterfaces = os.networkInterfaces();
  const urls = new Set();
  
  // 添加localhost
  urls.add(`http://localhost:${port}`);
  
  // 添加所有网络接口的IP
  Object.values(networkInterfaces).forEach(interfaces => {
    interfaces.forEach(iface => {
      // 只添加IPv4地址且非内部地址
      if (iface.family === 'IPv4' && !iface.internal) {
        urls.add(`http://${iface.address}:${port}`);
      }
    });
  });
  
  return Array.from(urls);
}

// 启动服务器
const PORT = process.env.PORT || 3000

// 初始化并启动
async function start() {
  try {
    await initDatabase();
    await loadModels();
    
    // 初始化IP授权状态
    await initializeAuthStatus();
    
    app.listen(PORT, '0.0.0.0', () => {
      const serverUrls = getServerUrls(PORT);
      
      console.log('\n=== 后端服务器已启动 ===');
      console.log('可通过以下地址访问:');
      serverUrls.forEach(url => {
        console.log(`- ${url}`);
      });
      console.log(`\nAPI前缀: ${API_PREFIX}`);
      console.log(`模型API路径: ${API_PREFIX}/models`);
      console.log(`数据库类型: ${config.databaseType}`);
      console.log(`已授权IP数量: ${authorizedIPCache.size}`);
      console.log('=========================\n');
    });
  } catch (error) {
    console.error('服务器启动失败:', error);
    process.exit(1);
  }
}

start()

// 添加测试接口
app.get('${API_PREFIX}/auth/test-ip/:ip', async (req, res) => {
  const { ip } = req.params;
  
  try {
    const authorizedIP = await AuthorizedIP.findOne({
      where: {
        ip,
        enabled: true
      }
    });
    
    res.json({
      ip,
      authorized: !!authorizedIP,
      details: authorizedIP || null,
      isLocal: getLocalIPs().has(ip)
    });
  } catch (error) {
    res.status(500).json({
      error: '检查IP失败',
      message: error.message
    });
  }
});

// 添加IP授权测试接口
app.get('${API_PREFIX}/auth/check-status', async (req, res) => {
  const clientIP = req.headers['x-forwarded-for']?.split(',')[0]?.trim() || 
                  req.headers['x-real-ip'] || 
                  req.connection.remoteAddress || 
                  req.ip;
  
  try {
    const authorizedIP = await AuthorizedIP.findOne({
      where: {
        ip: clientIP
      }
    });

    res.json({
      ip: clientIP,
      status: {
        isAuthorized: !!authorizedIP,
        isEnabled: authorizedIP?.enabled ?? false,
        lastAccess: authorizedIP?.lastAccess,
        description: authorizedIP?.description
      },
      message: authorizedIP?.enabled 
        ? '您的IP已授权可以访问' 
        : (authorizedIP 
          ? '您的IP已被禁用' 
          : '您的IP未授权')
    });
  } catch (error) {
    console.error('检查IP状态失败:', error);
    res.status(500).json({
      error: '检查IP状态失败',
      message: error.message
    });
  }
}); 